// Generated from Query.g4 by ANTLR 4.5
package org.codefinger.dao.impl;

import java.util.List;

import org.codefinger.dao.antlr.v4.runtime.FailedPredicateException;
import org.codefinger.dao.antlr.v4.runtime.NoViableAltException;
import org.codefinger.dao.antlr.v4.runtime.ParserRuleContext;
import org.codefinger.dao.antlr.v4.runtime.RecognitionException;
import org.codefinger.dao.antlr.v4.runtime.RuleContext;
import org.codefinger.dao.antlr.v4.runtime.RuntimeMetaData;
import org.codefinger.dao.antlr.v4.runtime.Token;
import org.codefinger.dao.antlr.v4.runtime.TokenStream;
import org.codefinger.dao.antlr.v4.runtime.Vocabulary;
import org.codefinger.dao.antlr.v4.runtime.VocabularyImpl;
import org.codefinger.dao.antlr.v4.runtime.atn.ATN;
import org.codefinger.dao.antlr.v4.runtime.atn.ATNDeserializer;
import org.codefinger.dao.antlr.v4.runtime.atn.ParserATNSimulator;
import org.codefinger.dao.antlr.v4.runtime.atn.PredictionContextCache;
import org.codefinger.dao.antlr.v4.runtime.dfa.DFA;
import org.codefinger.dao.antlr.v4.runtime.tree.TerminalNode;
import org.codefinger.dao.util.Lang;

@SuppressWarnings({ "all", "warnings", "unchecked", "unused", "cast" })
public class QueryParser extends QueryParserHelper {
	static {
		RuntimeMetaData.checkVersion("4.5", RuntimeMetaData.VERSION);
	}

	protected static final DFA[]					_decisionToDFA;
	protected static final PredictionContextCache	_sharedContextCache	= new PredictionContextCache();
	public static final int							SELECT				= 1, DISTINCT = 2, AS = 3, COUNT = 4, SUM = 5, AVG = 6, MAX = 7, MIN = 8, FROM = 9, CHECK = 10, INNER = 11, LEFT = 12, JOIN = 13, ON = 14, WHERE = 15, GROUP = 16, BY = 17, HAVING = 18, UNION = 19, ALL = 20, ORDER = 21, ASC = 22, DESC = 23, ANY = 24, EXISTS = 25, LIKE = 26, IN = 27, NOT = 28, IS = 29, NULL = 30, CASE = 31, WHEN = 32, THEN = 33, ELSE = 34, END = 35, BETWEEN = 36, AND = 37, OR = 38, ASTERISK = 39, COMMA = 40, PERIOD = 41, COLON = 42, L_BRACKET = 43, R_BRACKET = 44, MINUS = 45, DIVISION = 46, ADD = 47, EQ = 48, LT = 49, GT = 50, LTEQ = 51, GTEQ = 52, NOTEQ = 53, QUEMARK = 54, ID = 55, NUMBER = 56, STRING = 57, WS = 58;
	public static final int							RULE_query			= 0, RULE_columns = 1, RULE_column = 2, RULE_from = 3, RULE_join = 4, RULE_where = 5, RULE_groups = 6, RULE_group = 7, RULE_having = 8, RULE_union = 9, RULE_orders = 10, RULE_order = 11, RULE_subquery = 12, RULE_expression = 13, RULE_condition = 14, RULE_list = 15, RULE_listItem = 16, RULE_setValues = 17, RULE_setValue = 18, RULE_insert = 19, RULE_insertValue = 20;
	public static final String[]					ruleNames			= { "query", "columns", "column", "from", "join", "where", "groups", "group", "having", "union", "orders", "order", "subquery", "expression", "condition", "list", "listItem", "setValues", "setValue", "insert", "insertValue" };

	private static final String[]					_LITERAL_NAMES		= { null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, "'*'", "','", "'.'", "':'", "'('", "')'", "'-'", "'/'", "'+'", "'='", "'<'", "'>'", "'<='", "'>='", "'!='", "'?'" };
	private static final String[]					_SYMBOLIC_NAMES		= { null, "SELECT", "DISTINCT", "AS", "COUNT", "SUM", "AVG", "MAX", "MIN", "FROM", "CHECK", "INNER", "LEFT", "JOIN", "ON", "WHERE", "GROUP", "BY", "HAVING", "UNION", "ALL", "ORDER", "ASC", "DESC", "ANY", "EXISTS", "LIKE", "IN", "NOT", "IS", "NULL", "CASE", "WHEN", "THEN", "ELSE", "END", "BETWEEN", "AND", "OR", "ASTERISK", "COMMA", "PERIOD", "COLON", "L_BRACKET", "R_BRACKET", "MINUS", "DIVISION", "ADD", "EQ", "LT", "GT", "LTEQ", "GTEQ", "NOTEQ", "QUEMARK", "ID", "NUMBER", "STRING", "WS" };
	public static final Vocabulary					VOCABULARY			= new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES);

	/**
	 * @deprecated Use {@link #VOCABULARY} instead.
	 */
	@Deprecated
	public static final String[]					tokenNames;
	static {
		tokenNames = new String[_SYMBOLIC_NAMES.length];
		for (int i = 0; i < tokenNames.length; i++) {
			tokenNames[i] = VOCABULARY.getLiteralName(i);
			if (tokenNames[i] == null) {
				tokenNames[i] = VOCABULARY.getSymbolicName(i);
			}

			if (tokenNames[i] == null) {
				tokenNames[i] = "<INVALID>";
			}
		}
	}

	@Override
	@Deprecated
	public String[] getTokenNames() {
		return tokenNames;
	}

	@Override
	public Vocabulary getVocabulary() {
		return VOCABULARY;
	}

	@Override
	public String getGrammarFileName() {
		return "Query.g4";
	}

	@Override
	public String[] getRuleNames() {
		return ruleNames;
	}

	@Override
	public String getSerializedATN() {
		return _serializedATN;
	}

	@Override
	public ATN getATN() {
		return _ATN;
	}

	public QueryParser(TokenStream input, DataAccesser dataAccesser) {
		super(input, dataAccesser);
		_interp = new ParserATNSimulator(this, _ATN, _decisionToDFA, _sharedContextCache);
	}

	public static class QueryContext extends ParserRuleContext {
		public TerminalNode SELECT() {
			return getToken(QueryParser.SELECT, 0);
		}

		public ColumnsContext columns() {
			return getRuleContext(ColumnsContext.class, 0);
		}

		public TerminalNode FROM() {
			return getToken(QueryParser.FROM, 0);
		}

		public FromContext from() {
			return getRuleContext(FromContext.class, 0);
		}

		public TerminalNode DISTINCT() {
			return getToken(QueryParser.DISTINCT, 0);
		}

		public List<JoinContext> join() {
			return getRuleContexts(JoinContext.class);
		}

		public JoinContext join(int i) {
			return getRuleContext(JoinContext.class, i);
		}

		public WhereContext where() {
			return getRuleContext(WhereContext.class, 0);
		}

		public TerminalNode GROUP() {
			return getToken(QueryParser.GROUP, 0);
		}

		public List<TerminalNode> BY() {
			return getTokens(QueryParser.BY);
		}

		public TerminalNode BY(int i) {
			return getToken(QueryParser.BY, i);
		}

		public GroupsContext groups() {
			return getRuleContext(GroupsContext.class, 0);
		}

		public HavingContext having() {
			return getRuleContext(HavingContext.class, 0);
		}

		public List<UnionContext> union() {
			return getRuleContexts(UnionContext.class);
		}

		public UnionContext union(int i) {
			return getRuleContext(UnionContext.class, i);
		}

		public TerminalNode ORDER() {
			return getToken(QueryParser.ORDER, 0);
		}

		public OrdersContext orders() {
			return getRuleContext(OrdersContext.class, 0);
		}

		public QueryContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}

		@Override
		public int getRuleIndex() {
			return RULE_query;
		}
	}

	public final QueryContext query() throws RecognitionException {
		QueryContext _localctx = new QueryContext(_ctx, getState());
		enterRule(_localctx, 0, RULE_query);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
				setState(42);
				match(SELECT);
				setState(45);
				_la = _input.LA(1);
				if (_la == DISTINCT) {
					{
						setState(43);
						match(DISTINCT);

						builder.setDistinct();

					}
				}

				setState(47);
				columns();
				setState(48);
				match(FROM);
				setState(49);
				from();
				setState(53);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while (_la == INNER || _la == LEFT) {
					{
						{
							setState(50);
							join();
						}
					}
					setState(55);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}

				builder.resolveColumns();

				setState(58);
				_la = _input.LA(1);
				if (_la == WHERE) {
					{
						setState(57);
						where();
					}
				}

				setState(63);
				_la = _input.LA(1);
				if (_la == GROUP) {
					{
						setState(60);
						match(GROUP);
						setState(61);
						match(BY);
						setState(62);
						groups();
					}
				}

				setState(66);
				_la = _input.LA(1);
				if (_la == HAVING) {
					{
						setState(65);
						having();
					}
				}

				setState(71);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while (_la == UNION) {
					{
						{
							setState(68);
							union();
						}
					}
					setState(73);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				setState(77);
				_la = _input.LA(1);
				if (_la == ORDER) {
					{
						setState(74);
						match(ORDER);
						setState(75);
						match(BY);
						setState(76);
						orders();
					}
				}

			}
		} catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		} finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ColumnsContext extends ParserRuleContext {
		public TerminalNode ASTERISK() {
			return getToken(QueryParser.ASTERISK, 0);
		}

		public List<ColumnContext> column() {
			return getRuleContexts(ColumnContext.class);
		}

		public ColumnContext column(int i) {
			return getRuleContext(ColumnContext.class, i);
		}

		public List<TerminalNode> COMMA() {
			return getTokens(QueryParser.COMMA);
		}

		public TerminalNode COMMA(int i) {
			return getToken(QueryParser.COMMA, i);
		}

		public ColumnsContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}

		@Override
		public int getRuleIndex() {
			return RULE_columns;
		}
	}

	public final ColumnsContext columns() throws RecognitionException {
		ColumnsContext _localctx = new ColumnsContext(_ctx, getState());
		enterRule(_localctx, 2, RULE_columns);
		int _la;
		try {
			setState(89);
			switch (_input.LA(1)) {
			case ASTERISK:
				enterOuterAlt(_localctx, 1);
				{
					setState(79);
					match(ASTERISK);

					builder.queryAllColumns();

				}
				break;
			case COUNT:
			case SUM:
			case AVG:
			case MAX:
			case MIN:
			case CASE:
			case COLON:
			case L_BRACKET:
			case MINUS:
			case QUEMARK:
			case ID:
			case NUMBER:
			case STRING:
				enterOuterAlt(_localctx, 2);
				{
					setState(81);
					column();
					setState(86);
					_errHandler.sync(this);
					_la = _input.LA(1);
					while (_la == COMMA) {
						{
							{
								setState(82);
								match(COMMA);
								setState(83);
								column();
							}
						}
						setState(88);
						_errHandler.sync(this);
						_la = _input.LA(1);
					}
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		} catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		} finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ColumnContext extends ParserRuleContext {
		public Token				ID;
		public Token				NAME;
		public ExpressionContext	exp;

		public List<TerminalNode> ID() {
			return getTokens(QueryParser.ID);
		}

		public TerminalNode ID(int i) {
			return getToken(QueryParser.ID, i);
		}

		public TerminalNode PERIOD() {
			return getToken(QueryParser.PERIOD, 0);
		}

		public TerminalNode ASTERISK() {
			return getToken(QueryParser.ASTERISK, 0);
		}

		public TerminalNode AS() {
			return getToken(QueryParser.AS, 0);
		}

		public ExpressionContext expression() {
			return getRuleContext(ExpressionContext.class, 0);
		}

		public ColumnContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}

		@Override
		public int getRuleIndex() {
			return RULE_column;
		}
	}

	public final ColumnContext column() throws RecognitionException {
		ColumnContext _localctx = new ColumnContext(_ctx, getState());
		enterRule(_localctx, 4, RULE_column);
		int _la;
		try {
			setState(123);
			switch (getInterpreter().adaptivePredict(_input, 14, _ctx)) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
					setState(91);
					_localctx.ID = match(ID);
					setState(92);
					match(PERIOD);
					setState(93);
					match(ASTERISK);

					builder.addAllColumns(_localctx.ID.getText());

				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{

					String tableAlias = null;
					String columnName = null;
					String alias = null;

					setState(102);
					switch (getInterpreter().adaptivePredict(_input, 9, _ctx)) {
					case 1: {
						setState(96);
						_localctx.ID = match(ID);

						columnName = _localctx.ID.getText();

					}
						break;
					case 2: {
						setState(98);
						_localctx.ID = match(ID);
						setState(99);
						match(PERIOD);
						setState(100);
						_localctx.NAME = match(ID);

						tableAlias = _localctx.ID.getText();
						columnName = _localctx.NAME.getText();

					}
						break;
					}
					setState(109);
					_la = _input.LA(1);
					if (_la == AS || _la == ID) {
						{
							setState(105);
							_la = _input.LA(1);
							if (_la == AS) {
								{
									setState(104);
									match(AS);
								}
							}

							setState(107);
							_localctx.ID = match(ID);

							alias = _localctx.ID.getText();

						}
					}

					if (tableAlias == null) {
						if (alias == null) {
							builder.addColumn(columnName);
						} else {
							builder.addAliasColumn(columnName, alias);
						}
					} else {
						if (alias == null) {
							builder.addColumn(tableAlias, columnName);
						} else {
							builder.addAliasColumn(tableAlias, columnName, alias);
						}
					}

				}
				break;
			case 3:
				enterOuterAlt(_localctx, 3);
				{

					String alias = null;

					setState(113);
					_localctx.exp = expression(0);
					setState(119);
					_la = _input.LA(1);
					if (_la == AS || _la == ID) {
						{
							setState(115);
							_la = _input.LA(1);
							if (_la == AS) {
								{
									setState(114);
									match(AS);
								}
							}

							setState(117);
							_localctx.ID = match(ID);

							alias = _localctx.ID.getText();

						}
					}

					if (alias == null) {
						throw Lang.makeThrow("You must set an alias for this column: %s.", _input.getText(_localctx.exp.start, _localctx.exp.stop));
					}
					builder.addExpColumn(alias);

				}
				break;
			}
		} catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		} finally {
			exitRule();
		}
		return _localctx;
	}

	public static class FromContext extends ParserRuleContext {
		public Token	TABLE;
		public Token	ID;

		public List<TerminalNode> ID() {
			return getTokens(QueryParser.ID);
		}

		public TerminalNode ID(int i) {
			return getToken(QueryParser.ID, i);
		}

		public TerminalNode AS() {
			return getToken(QueryParser.AS, 0);
		}

		public TerminalNode L_BRACKET() {
			return getToken(QueryParser.L_BRACKET, 0);
		}

		public QueryContext query() {
			return getRuleContext(QueryContext.class, 0);
		}

		public TerminalNode R_BRACKET() {
			return getToken(QueryParser.R_BRACKET, 0);
		}

		public FromContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}

		@Override
		public int getRuleIndex() {
			return RULE_from;
		}
	}

	public final FromContext from() throws RecognitionException {
		FromContext _localctx = new FromContext(_ctx, getState());
		enterRule(_localctx, 6, RULE_from);
		int _la;
		try {
			setState(148);
			switch (_input.LA(1)) {
			case ID:
				enterOuterAlt(_localctx, 1);
				{

					String alias = null;

					setState(126);
					_localctx.TABLE = match(ID);
					setState(132);
					_la = _input.LA(1);
					if (_la == AS || _la == ID) {
						{
							setState(128);
							_la = _input.LA(1);
							if (_la == AS) {
								{
									setState(127);
									match(AS);
								}
							}

							setState(130);
							_localctx.ID = match(ID);

							alias = _localctx.ID.getText();

						}
					}

					if (alias == null) {
						builder.setFrom(_localctx.TABLE.getText());
					} else {
						builder.setFrom(_localctx.TABLE.getText(), alias);
					}

				}
				break;
			case L_BRACKET:
				enterOuterAlt(_localctx, 2);
				{
					setState(135);
					match(L_BRACKET);

					beginSubQuery();
					String alias = null;

					setState(137);
					query();
					setState(138);
					match(R_BRACKET);
					setState(144);
					_la = _input.LA(1);
					if (_la == AS || _la == ID) {
						{
							setState(140);
							_la = _input.LA(1);
							if (_la == AS) {
								{
									setState(139);
									match(AS);
								}
							}

							setState(142);
							_localctx.ID = match(ID);

							alias = _localctx.ID.getText();

						}
					}

					if (alias == null) {
						throw Lang.makeThrow("You must set an alias at the end of the from.");
					}
					setSubQueryFrom(alias);

				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		} catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		} finally {
			exitRule();
		}
		return _localctx;
	}

	public static class JoinContext extends ParserRuleContext {
		public Token	op;
		public Token	TABLE;
		public Token	ID;

		public TerminalNode JOIN() {
			return getToken(QueryParser.JOIN, 0);
		}

		public TerminalNode ON() {
			return getToken(QueryParser.ON, 0);
		}

		public ConditionContext condition() {
			return getRuleContext(ConditionContext.class, 0);
		}

		public List<TerminalNode> ID() {
			return getTokens(QueryParser.ID);
		}

		public TerminalNode ID(int i) {
			return getToken(QueryParser.ID, i);
		}

		public TerminalNode INNER() {
			return getToken(QueryParser.INNER, 0);
		}

		public TerminalNode LEFT() {
			return getToken(QueryParser.LEFT, 0);
		}

		public TerminalNode AS() {
			return getToken(QueryParser.AS, 0);
		}

		public JoinContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}

		@Override
		public int getRuleIndex() {
			return RULE_join;
		}
	}

	public final JoinContext join() throws RecognitionException {
		JoinContext _localctx = new JoinContext(_ctx, getState());
		enterRule(_localctx, 8, RULE_join);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
				setState(150);
				_localctx.op = _input.LT(1);
				_la = _input.LA(1);
				if (!(_la == INNER || _la == LEFT)) {
					_localctx.op = _errHandler.recoverInline(this);
				} else {
					consume();
				}

				String alias = null;

				setState(152);
				match(JOIN);
				setState(153);
				_localctx.TABLE = match(ID);
				setState(159);
				_la = _input.LA(1);
				if (_la == AS || _la == ID) {
					{
						setState(155);
						_la = _input.LA(1);
						if (_la == AS) {
							{
								setState(154);
								match(AS);
							}
						}

						setState(157);
						_localctx.ID = match(ID);

						alias = _localctx.ID.getText();

					}
				}

				setState(161);
				match(ON);
				setState(162);
				condition(0);

				if (alias == null) {
					builder.addJoin(_localctx.op.getType() == INNER, _localctx.TABLE.getText());
				} else {
					builder.addJoin(_localctx.op.getType() == INNER, _localctx.TABLE.getText(), alias);
				}

			}
		} catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		} finally {
			exitRule();
		}
		return _localctx;
	}

	public static class WhereContext extends ParserRuleContext {
		public TerminalNode WHERE() {
			return getToken(QueryParser.WHERE, 0);
		}

		public ConditionContext condition() {
			return getRuleContext(ConditionContext.class, 0);
		}

		public WhereContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}

		@Override
		public int getRuleIndex() {
			return RULE_where;
		}
	}

	public final WhereContext where() throws RecognitionException {
		WhereContext _localctx = new WhereContext(_ctx, getState());
		enterRule(_localctx, 10, RULE_where);
		try {
			enterOuterAlt(_localctx, 1);
			{
				setState(165);
				match(WHERE);
				setState(166);
				condition(0);

				builder.setWhere();

			}
		} catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		} finally {
			exitRule();
		}
		return _localctx;
	}

	public static class GroupsContext extends ParserRuleContext {
		public List<GroupContext> group() {
			return getRuleContexts(GroupContext.class);
		}

		public GroupContext group(int i) {
			return getRuleContext(GroupContext.class, i);
		}

		public List<TerminalNode> COMMA() {
			return getTokens(QueryParser.COMMA);
		}

		public TerminalNode COMMA(int i) {
			return getToken(QueryParser.COMMA, i);
		}

		public GroupsContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}

		@Override
		public int getRuleIndex() {
			return RULE_groups;
		}
	}

	public final GroupsContext groups() throws RecognitionException {
		GroupsContext _localctx = new GroupsContext(_ctx, getState());
		enterRule(_localctx, 12, RULE_groups);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
				setState(169);
				group();
				setState(174);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while (_la == COMMA) {
					{
						{
							setState(170);
							match(COMMA);
							setState(171);
							group();
						}
					}
					setState(176);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
			}
		} catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		} finally {
			exitRule();
		}
		return _localctx;
	}

	public static class GroupContext extends ParserRuleContext {
		public Token	ID;
		public Token	TABLE;

		public List<TerminalNode> ID() {
			return getTokens(QueryParser.ID);
		}

		public TerminalNode ID(int i) {
			return getToken(QueryParser.ID, i);
		}

		public TerminalNode PERIOD() {
			return getToken(QueryParser.PERIOD, 0);
		}

		public TerminalNode ASTERISK() {
			return getToken(QueryParser.ASTERISK, 0);
		}

		public GroupContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}

		@Override
		public int getRuleIndex() {
			return RULE_group;
		}
	}

	public final GroupContext group() throws RecognitionException {
		GroupContext _localctx = new GroupContext(_ctx, getState());
		enterRule(_localctx, 14, RULE_group);
		try {
			setState(187);
			switch (getInterpreter().adaptivePredict(_input, 23, _ctx)) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
					setState(177);
					_localctx.ID = match(ID);

					builder.addGroup(_localctx.ID.getText());

				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
					setState(179);
					_localctx.TABLE = match(ID);
					setState(180);
					match(PERIOD);
					setState(181);
					_localctx.ID = match(ID);

					builder.addGroup(_localctx.TABLE.getText(), _localctx.ID.getText());

				}
				break;
			case 3:
				enterOuterAlt(_localctx, 3);
				{
					setState(183);
					_localctx.ID = match(ID);
					setState(184);
					match(PERIOD);
					setState(185);
					match(ASTERISK);

					builder.addAllGroups(_localctx.ID.getText());

				}
				break;
			}
		} catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		} finally {
			exitRule();
		}
		return _localctx;
	}

	public static class HavingContext extends ParserRuleContext {
		public TerminalNode HAVING() {
			return getToken(QueryParser.HAVING, 0);
		}

		public ConditionContext condition() {
			return getRuleContext(ConditionContext.class, 0);
		}

		public HavingContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}

		@Override
		public int getRuleIndex() {
			return RULE_having;
		}
	}

	public final HavingContext having() throws RecognitionException {
		HavingContext _localctx = new HavingContext(_ctx, getState());
		enterRule(_localctx, 16, RULE_having);
		try {
			enterOuterAlt(_localctx, 1);
			{
				setState(189);
				match(HAVING);
				setState(190);
				condition(0);

				builder.setHaving();

			}
		} catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		} finally {
			exitRule();
		}
		return _localctx;
	}

	public static class UnionContext extends ParserRuleContext {
		public TerminalNode UNION() {
			return getToken(QueryParser.UNION, 0);
		}

		public TerminalNode SELECT() {
			return getToken(QueryParser.SELECT, 0);
		}

		public ColumnsContext columns() {
			return getRuleContext(ColumnsContext.class, 0);
		}

		public TerminalNode FROM() {
			return getToken(QueryParser.FROM, 0);
		}

		public FromContext from() {
			return getRuleContext(FromContext.class, 0);
		}

		public TerminalNode ALL() {
			return getToken(QueryParser.ALL, 0);
		}

		public TerminalNode DISTINCT() {
			return getToken(QueryParser.DISTINCT, 0);
		}

		public List<JoinContext> join() {
			return getRuleContexts(JoinContext.class);
		}

		public JoinContext join(int i) {
			return getRuleContext(JoinContext.class, i);
		}

		public WhereContext where() {
			return getRuleContext(WhereContext.class, 0);
		}

		public TerminalNode GROUP() {
			return getToken(QueryParser.GROUP, 0);
		}

		public TerminalNode BY() {
			return getToken(QueryParser.BY, 0);
		}

		public GroupsContext groups() {
			return getRuleContext(GroupsContext.class, 0);
		}

		public HavingContext having() {
			return getRuleContext(HavingContext.class, 0);
		}

		public UnionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}

		@Override
		public int getRuleIndex() {
			return RULE_union;
		}
	}

	public final UnionContext union() throws RecognitionException {
		UnionContext _localctx = new UnionContext(_ctx, getState());
		enterRule(_localctx, 18, RULE_union);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
				setState(193);
				match(UNION);

				boolean isAll = false;

				setState(197);
				_la = _input.LA(1);
				if (_la == ALL) {
					{
						setState(195);
						match(ALL);

						isAll = true;

					}
				}

				beginSubQuery();

				setState(200);
				match(SELECT);
				setState(203);
				_la = _input.LA(1);
				if (_la == DISTINCT) {
					{
						setState(201);
						match(DISTINCT);

						builder.setDistinct();

					}
				}

				setState(205);
				columns();
				setState(206);
				match(FROM);
				setState(207);
				from();
				setState(211);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while (_la == INNER || _la == LEFT) {
					{
						{
							setState(208);
							join();
						}
					}
					setState(213);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}

				builder.resolveColumns();

				setState(216);
				_la = _input.LA(1);
				if (_la == WHERE) {
					{
						setState(215);
						where();
					}
				}

				setState(221);
				_la = _input.LA(1);
				if (_la == GROUP) {
					{
						setState(218);
						match(GROUP);
						setState(219);
						match(BY);
						setState(220);
						groups();
					}
				}

				setState(224);
				_la = _input.LA(1);
				if (_la == HAVING) {
					{
						setState(223);
						having();
					}
				}

				if (isAll) {
					addUnionAll();
				} else {
					addUnion();
				}

			}
		} catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		} finally {
			exitRule();
		}
		return _localctx;
	}

	public static class OrdersContext extends ParserRuleContext {
		public List<OrderContext> order() {
			return getRuleContexts(OrderContext.class);
		}

		public OrderContext order(int i) {
			return getRuleContext(OrderContext.class, i);
		}

		public List<TerminalNode> COMMA() {
			return getTokens(QueryParser.COMMA);
		}

		public TerminalNode COMMA(int i) {
			return getToken(QueryParser.COMMA, i);
		}

		public OrdersContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}

		@Override
		public int getRuleIndex() {
			return RULE_orders;
		}
	}

	public final OrdersContext orders() throws RecognitionException {
		OrdersContext _localctx = new OrdersContext(_ctx, getState());
		enterRule(_localctx, 20, RULE_orders);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
				setState(228);
				order();
				setState(233);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while (_la == COMMA) {
					{
						{
							setState(229);
							match(COMMA);
							setState(230);
							order();
						}
					}
					setState(235);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
			}
		} catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		} finally {
			exitRule();
		}
		return _localctx;
	}

	public static class OrderContext extends ParserRuleContext {
		public Token	op;

		public ExpressionContext expression() {
			return getRuleContext(ExpressionContext.class, 0);
		}

		public TerminalNode ASC() {
			return getToken(QueryParser.ASC, 0);
		}

		public TerminalNode DESC() {
			return getToken(QueryParser.DESC, 0);
		}

		public OrderContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}

		@Override
		public int getRuleIndex() {
			return RULE_order;
		}
	}

	public final OrderContext order() throws RecognitionException {
		OrderContext _localctx = new OrderContext(_ctx, getState());
		enterRule(_localctx, 22, RULE_order);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
				setState(236);
				expression(0);
				setState(238);
				_la = _input.LA(1);
				if (_la == ASC || _la == DESC) {
					{
						setState(237);
						_localctx.op = _input.LT(1);
						_la = _input.LA(1);
						if (!(_la == ASC || _la == DESC)) {
							_localctx.op = _errHandler.recoverInline(this);
						} else {
							consume();
						}
					}
				}

				if (_localctx.op == null || _localctx.op.getType() == ASC) {
					builder.addAsc();
				} else {
					builder.addDesc();
				}

			}
		} catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		} finally {
			exitRule();
		}
		return _localctx;
	}

	public static class SubqueryContext extends ParserRuleContext {
		public TerminalNode L_BRACKET() {
			return getToken(QueryParser.L_BRACKET, 0);
		}

		public TerminalNode SELECT() {
			return getToken(QueryParser.SELECT, 0);
		}

		public ColumnsContext columns() {
			return getRuleContext(ColumnsContext.class, 0);
		}

		public TerminalNode FROM() {
			return getToken(QueryParser.FROM, 0);
		}

		public FromContext from() {
			return getRuleContext(FromContext.class, 0);
		}

		public TerminalNode R_BRACKET() {
			return getToken(QueryParser.R_BRACKET, 0);
		}

		public TerminalNode DISTINCT() {
			return getToken(QueryParser.DISTINCT, 0);
		}

		public List<JoinContext> join() {
			return getRuleContexts(JoinContext.class);
		}

		public JoinContext join(int i) {
			return getRuleContext(JoinContext.class, i);
		}

		public WhereContext where() {
			return getRuleContext(WhereContext.class, 0);
		}

		public TerminalNode GROUP() {
			return getToken(QueryParser.GROUP, 0);
		}

		public TerminalNode BY() {
			return getToken(QueryParser.BY, 0);
		}

		public GroupsContext groups() {
			return getRuleContext(GroupsContext.class, 0);
		}

		public HavingContext having() {
			return getRuleContext(HavingContext.class, 0);
		}

		public List<UnionContext> union() {
			return getRuleContexts(UnionContext.class);
		}

		public UnionContext union(int i) {
			return getRuleContext(UnionContext.class, i);
		}

		public SubqueryContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}

		@Override
		public int getRuleIndex() {
			return RULE_subquery;
		}
	}

	public final SubqueryContext subquery() throws RecognitionException {
		SubqueryContext _localctx = new SubqueryContext(_ctx, getState());
		enterRule(_localctx, 24, RULE_subquery);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
				setState(242);
				match(L_BRACKET);

				beginSubQuery();

				setState(244);
				match(SELECT);
				setState(247);
				_la = _input.LA(1);
				if (_la == DISTINCT) {
					{
						setState(245);
						match(DISTINCT);

						builder.setDistinct();

					}
				}

				setState(249);
				columns();
				setState(250);
				match(FROM);
				setState(251);
				from();
				setState(255);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while (_la == INNER || _la == LEFT) {
					{
						{
							setState(252);
							join();
						}
					}
					setState(257);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}

				builder.resolveColumns();

				setState(260);
				_la = _input.LA(1);
				if (_la == WHERE) {
					{
						setState(259);
						where();
					}
				}

				setState(265);
				_la = _input.LA(1);
				if (_la == GROUP) {
					{
						setState(262);
						match(GROUP);
						setState(263);
						match(BY);
						setState(264);
						groups();
					}
				}

				setState(268);
				_la = _input.LA(1);
				if (_la == HAVING) {
					{
						setState(267);
						having();
					}
				}

				setState(273);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while (_la == UNION) {
					{
						{
							setState(270);
							union();
						}
					}
					setState(275);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				setState(276);
				match(R_BRACKET);

				endSubQuery();

			}
		} catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		} finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ExpressionContext extends ParserRuleContext {
		public Token	ID;
		public Token	TABLE;
		public Token	NUMBER;
		public Token	STRING;
		public Token	op;

		public TerminalNode MINUS() {
			return getToken(QueryParser.MINUS, 0);
		}

		public List<ExpressionContext> expression() {
			return getRuleContexts(ExpressionContext.class);
		}

		public ExpressionContext expression(int i) {
			return getRuleContext(ExpressionContext.class, i);
		}

		public List<TerminalNode> ID() {
			return getTokens(QueryParser.ID);
		}

		public TerminalNode ID(int i) {
			return getToken(QueryParser.ID, i);
		}

		public TerminalNode PERIOD() {
			return getToken(QueryParser.PERIOD, 0);
		}

		public TerminalNode NUMBER() {
			return getToken(QueryParser.NUMBER, 0);
		}

		public TerminalNode STRING() {
			return getToken(QueryParser.STRING, 0);
		}

		public TerminalNode COLON() {
			return getToken(QueryParser.COLON, 0);
		}

		public TerminalNode QUEMARK() {
			return getToken(QueryParser.QUEMARK, 0);
		}

		public TerminalNode L_BRACKET() {
			return getToken(QueryParser.L_BRACKET, 0);
		}

		public TerminalNode R_BRACKET() {
			return getToken(QueryParser.R_BRACKET, 0);
		}

		public TerminalNode COUNT() {
			return getToken(QueryParser.COUNT, 0);
		}

		public TerminalNode SUM() {
			return getToken(QueryParser.SUM, 0);
		}

		public TerminalNode AVG() {
			return getToken(QueryParser.AVG, 0);
		}

		public TerminalNode MAX() {
			return getToken(QueryParser.MAX, 0);
		}

		public TerminalNode MIN() {
			return getToken(QueryParser.MIN, 0);
		}

		public TerminalNode DISTINCT() {
			return getToken(QueryParser.DISTINCT, 0);
		}

		public List<TerminalNode> COMMA() {
			return getTokens(QueryParser.COMMA);
		}

		public TerminalNode COMMA(int i) {
			return getToken(QueryParser.COMMA, i);
		}

		public SubqueryContext subquery() {
			return getRuleContext(SubqueryContext.class, 0);
		}

		public TerminalNode CASE() {
			return getToken(QueryParser.CASE, 0);
		}

		public TerminalNode ELSE() {
			return getToken(QueryParser.ELSE, 0);
		}

		public TerminalNode END() {
			return getToken(QueryParser.END, 0);
		}

		public List<TerminalNode> WHEN() {
			return getTokens(QueryParser.WHEN);
		}

		public TerminalNode WHEN(int i) {
			return getToken(QueryParser.WHEN, i);
		}

		public List<ConditionContext> condition() {
			return getRuleContexts(ConditionContext.class);
		}

		public ConditionContext condition(int i) {
			return getRuleContext(ConditionContext.class, i);
		}

		public List<TerminalNode> THEN() {
			return getTokens(QueryParser.THEN);
		}

		public TerminalNode THEN(int i) {
			return getToken(QueryParser.THEN, i);
		}

		public TerminalNode ASTERISK() {
			return getToken(QueryParser.ASTERISK, 0);
		}

		public TerminalNode DIVISION() {
			return getToken(QueryParser.DIVISION, 0);
		}

		public TerminalNode ADD() {
			return getToken(QueryParser.ADD, 0);
		}

		public ExpressionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}

		@Override
		public int getRuleIndex() {
			return RULE_expression;
		}
	}

	public final ExpressionContext expression() throws RecognitionException {
		return expression(0);
	}

	private ExpressionContext expression(int _p) throws RecognitionException {
		ParserRuleContext _parentctx = _ctx;
		int _parentState = getState();
		ExpressionContext _localctx = new ExpressionContext(_ctx, _parentState);
		ExpressionContext _prevctx = _localctx;
		int _startState = 26;
		enterRecursionRule(_localctx, 26, RULE_expression, _p);
		int _la;
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
				setState(369);
				switch (getInterpreter().adaptivePredict(_input, 43, _ctx)) {
				case 1: {
					setState(280);
					match(MINUS);
					setState(281);
					expression(6);

					builder.pushMinus();

				}
					break;
				case 2: {
					setState(284);
					_localctx.ID = match(ID);

					builder.pushID(_localctx.ID.getText());

				}
					break;
				case 3: {
					setState(286);
					_localctx.TABLE = match(ID);
					setState(287);
					match(PERIOD);
					setState(288);
					_localctx.ID = match(ID);

					builder.pushID(_localctx.TABLE.getText(), _localctx.ID.getText());

				}
					break;
				case 4: {
					setState(290);
					_localctx.NUMBER = match(NUMBER);

					builder.pushNumber(_localctx.NUMBER.getText());

				}
					break;
				case 5: {
					setState(292);
					_localctx.STRING = match(STRING);

					builder.pushString(_localctx.STRING.getText());

				}
					break;
				case 6: {
					setState(294);
					match(COLON);
					setState(295);
					_localctx.ID = match(ID);

					builder.pushParam(_localctx.ID.getText());

				}
					break;
				case 7: {
					setState(297);
					match(QUEMARK);

					builder.pushParam(nextParamIndex());

				}
					break;
				case 8: {
					setState(299);
					_localctx.op = _input.LT(1);
					_la = _input.LA(1);
					if (!((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << COUNT) | (1L << SUM) | (1L << AVG) | (1L << MAX) | (1L << MIN))) != 0))) {
						_localctx.op = _errHandler.recoverInline(this);
					} else {
						consume();
					}
					setState(300);
					match(L_BRACKET);

					boolean isDistinct = false;

					setState(304);
					_la = _input.LA(1);
					if (_la == DISTINCT) {
						{
							setState(302);
							match(DISTINCT);

							isDistinct = true;

						}
					}

					setState(306);
					expression(0);
					setState(307);
					match(R_BRACKET);

					if (isDistinct) {
						builder.pushDisAggregation(_localctx.op.getText());
					} else {
						builder.pushAggregation(_localctx.op.getText());
					}

				}
					break;
				case 9: {
					setState(310);
					_localctx.ID = match(ID);
					setState(311);
					match(L_BRACKET);

					int length = 0;

					setState(324);
					_la = _input.LA(1);
					if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << COUNT) | (1L << SUM) | (1L << AVG) | (1L << MAX) | (1L << MIN) | (1L << CASE) | (1L << COLON) | (1L << L_BRACKET) | (1L << MINUS) | (1L << QUEMARK) | (1L << ID) | (1L << NUMBER) | (1L << STRING))) != 0)) {
						{
							setState(313);
							expression(0);

							length++;

							setState(321);
							_errHandler.sync(this);
							_la = _input.LA(1);
							while (_la == COMMA) {
								{
									{
										setState(315);
										match(COMMA);
										setState(316);
										expression(0);

										length++;

									}
								}
								setState(323);
								_errHandler.sync(this);
								_la = _input.LA(1);
							}
						}
					}

					setState(326);
					match(R_BRACKET);

					builder.pushFunction(_localctx.ID.getText(), length);

				}
					break;
				case 10: {
					setState(328);
					subquery();
				}
					break;
				case 11: {
					setState(329);
					match(L_BRACKET);
					setState(330);
					expression(0);
					setState(331);
					match(R_BRACKET);

					builder.pushBracket();

				}
					break;
				case 12: {
					setState(334);
					match(CASE);

					int length = 0;

					setState(342);
					_errHandler.sync(this);
					_la = _input.LA(1);
					do {
						{
							{
								setState(336);
								match(WHEN);
								setState(337);
								condition(0);
								setState(338);
								match(THEN);
								setState(339);
								expression(0);

								length++;

							}
						}
						setState(344);
						_errHandler.sync(this);
						_la = _input.LA(1);
					} while (_la == WHEN);
					setState(346);
					match(ELSE);
					setState(347);
					expression(0);
					setState(348);
					match(END);

					builder.pushIfCase(length);

				}
					break;
				case 13: {
					setState(351);
					match(CASE);
					setState(352);
					expression(0);

					int length = 0;

					setState(360);
					_errHandler.sync(this);
					_la = _input.LA(1);
					do {
						{
							{
								setState(354);
								match(WHEN);
								setState(355);
								expression(0);
								setState(356);
								match(THEN);
								setState(357);
								expression(0);

								length++;

							}
						}
						setState(362);
						_errHandler.sync(this);
						_la = _input.LA(1);
					} while (_la == WHEN);
					setState(364);
					match(ELSE);
					setState(365);
					expression(0);
					setState(366);
					match(END);

					builder.pushSwitchCase(length);

				}
					break;
				}
				_ctx.stop = _input.LT(-1);
				setState(383);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input, 45, _ctx);
				while (_alt != 2 && _alt != org.codefinger.dao.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) {
					if (_alt == 1) {
						if (_parseListeners != null)
							triggerExitRuleEvent();
						_prevctx = _localctx;
						{
							setState(381);
							switch (getInterpreter().adaptivePredict(_input, 44, _ctx)) {
							case 1: {
								_localctx = new ExpressionContext(_parentctx, _parentState);
								pushNewRecursionContext(_localctx, _startState, RULE_expression);
								setState(371);
								if (!(precpred(_ctx, 4)))
									throw new FailedPredicateException(this, "precpred(_ctx, 4)");
								setState(372);
								_localctx.op = _input.LT(1);
								_la = _input.LA(1);
								if (!(_la == ASTERISK || _la == DIVISION)) {
									_localctx.op = _errHandler.recoverInline(this);
								} else {
									consume();
								}
								setState(373);
								expression(5);

								if (_localctx.op.getType() == ASTERISK) {
									builder.pushMultiplication();
								} else {
									builder.pushDivision();
								}

							}
								break;
							case 2: {
								_localctx = new ExpressionContext(_parentctx, _parentState);
								pushNewRecursionContext(_localctx, _startState, RULE_expression);
								setState(376);
								if (!(precpred(_ctx, 3)))
									throw new FailedPredicateException(this, "precpred(_ctx, 3)");
								setState(377);
								_localctx.op = _input.LT(1);
								_la = _input.LA(1);
								if (!(_la == MINUS || _la == ADD)) {
									_localctx.op = _errHandler.recoverInline(this);
								} else {
									consume();
								}
								setState(378);
								expression(4);

								if (_localctx.op.getType() == ADD) {
									builder.pushAdd();
								} else {
									builder.pushSubtraction();
								}

							}
								break;
							}
						}
					}
					setState(385);
					_errHandler.sync(this);
					_alt = getInterpreter().adaptivePredict(_input, 45, _ctx);
				}
			}
		} catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		} finally {
			unrollRecursionContexts(_parentctx);
		}
		return _localctx;
	}

	public static class ConditionContext extends ParserRuleContext {
		public Token	op;
		public Token	o;
		public Token	ID;

		public List<ExpressionContext> expression() {
			return getRuleContexts(ExpressionContext.class);
		}

		public ExpressionContext expression(int i) {
			return getRuleContext(ExpressionContext.class, i);
		}

		public TerminalNode EQ() {
			return getToken(QueryParser.EQ, 0);
		}

		public TerminalNode LT() {
			return getToken(QueryParser.LT, 0);
		}

		public TerminalNode GT() {
			return getToken(QueryParser.GT, 0);
		}

		public TerminalNode LTEQ() {
			return getToken(QueryParser.LTEQ, 0);
		}

		public TerminalNode GTEQ() {
			return getToken(QueryParser.GTEQ, 0);
		}

		public TerminalNode NOTEQ() {
			return getToken(QueryParser.NOTEQ, 0);
		}

		public SubqueryContext subquery() {
			return getRuleContext(SubqueryContext.class, 0);
		}

		public TerminalNode ANY() {
			return getToken(QueryParser.ANY, 0);
		}

		public TerminalNode ALL() {
			return getToken(QueryParser.ALL, 0);
		}

		public TerminalNode LIKE() {
			return getToken(QueryParser.LIKE, 0);
		}

		public TerminalNode NOT() {
			return getToken(QueryParser.NOT, 0);
		}

		public TerminalNode LEFT() {
			return getToken(QueryParser.LEFT, 0);
		}

		public TerminalNode COLON() {
			return getToken(QueryParser.COLON, 0);
		}

		public TerminalNode ID() {
			return getToken(QueryParser.ID, 0);
		}

		public TerminalNode QUEMARK() {
			return getToken(QueryParser.QUEMARK, 0);
		}

		public TerminalNode IN() {
			return getToken(QueryParser.IN, 0);
		}

		public ListContext list() {
			return getRuleContext(ListContext.class, 0);
		}

		public TerminalNode EXISTS() {
			return getToken(QueryParser.EXISTS, 0);
		}

		public TerminalNode IS() {
			return getToken(QueryParser.IS, 0);
		}

		public TerminalNode NULL() {
			return getToken(QueryParser.NULL, 0);
		}

		public TerminalNode BETWEEN() {
			return getToken(QueryParser.BETWEEN, 0);
		}

		public TerminalNode AND() {
			return getToken(QueryParser.AND, 0);
		}

		public TerminalNode L_BRACKET() {
			return getToken(QueryParser.L_BRACKET, 0);
		}

		public List<ConditionContext> condition() {
			return getRuleContexts(ConditionContext.class);
		}

		public ConditionContext condition(int i) {
			return getRuleContext(ConditionContext.class, i);
		}

		public TerminalNode R_BRACKET() {
			return getToken(QueryParser.R_BRACKET, 0);
		}

		public TerminalNode OR() {
			return getToken(QueryParser.OR, 0);
		}

		public ConditionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}

		@Override
		public int getRuleIndex() {
			return RULE_condition;
		}
	}

	public final ConditionContext condition() throws RecognitionException {
		return condition(0);
	}

	private ConditionContext condition(int _p) throws RecognitionException {
		ParserRuleContext _parentctx = _ctx;
		int _parentState = getState();
		ConditionContext _localctx = new ConditionContext(_ctx, _parentState);
		ConditionContext _prevctx = _localctx;
		int _startState = 28;
		enterRecursionRule(_localctx, 28, RULE_condition, _p);
		int _la;
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
				setState(469);
				switch (getInterpreter().adaptivePredict(_input, 54, _ctx)) {
				case 1: {
					setState(387);
					expression(0);
					setState(388);
					_localctx.op = _input.LT(1);
					_la = _input.LA(1);
					if (!((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << EQ) | (1L << LT) | (1L << GT) | (1L << LTEQ) | (1L << GTEQ) | (1L << NOTEQ))) != 0))) {
						_localctx.op = _errHandler.recoverInline(this);
					} else {
						consume();
					}
					setState(394);
					switch (_input.LA(1)) {
					case COUNT:
					case SUM:
					case AVG:
					case MAX:
					case MIN:
					case CASE:
					case COLON:
					case L_BRACKET:
					case MINUS:
					case QUEMARK:
					case ID:
					case NUMBER:
					case STRING: {
						setState(389);
						expression(0);
					}
						break;
					case ALL:
					case ANY: {
						setState(390);
						_localctx.o = _input.LT(1);
						_la = _input.LA(1);
						if (!(_la == ALL || _la == ANY)) {
							_localctx.o = _errHandler.recoverInline(this);
						} else {
							consume();
						}
						setState(391);
						subquery();

						if (_localctx.o.getType() == ANY) {
							builder.pushAny();
						} else {
							builder.pushAll();
						}

					}
						break;
					default:
						throw new NoViableAltException(this);
					}

					switch (_localctx.op.getType()) {
					case EQ:
						builder.pushEQ();
						break;
					case LT:
						builder.pushLT();
						break;
					case GT:
						builder.pushGT();
						break;
					case LTEQ:
						builder.pushLTEQ();
						break;
					case GTEQ:
						builder.pushGTEQ();
						break;
					default:
						builder.pushNotEQ();
						break;
					}

				}
					break;
				case 2: {
					setState(398);
					expression(0);

					boolean isNot = false;

					setState(402);
					_la = _input.LA(1);
					if (_la == NOT) {
						{
							setState(400);
							match(NOT);

							isNot = true;

						}
					}

					setState(404);
					match(LIKE);
					setState(405);
					expression(0);

					if (isNot) {
						builder.pushNotLike();
					} else {
						builder.pushLike();
					}

				}
					break;
				case 3: {
					setState(408);
					expression(0);

					boolean isNot = false;

					setState(412);
					_la = _input.LA(1);
					if (_la == NOT) {
						{
							setState(410);
							match(NOT);

							isNot = true;

						}
					}

					setState(414);
					_localctx.op = _input.LT(1);
					_la = _input.LA(1);
					if (!(_la == LEFT || _la == ALL)) {
						_localctx.op = _errHandler.recoverInline(this);
					} else {
						consume();
					}
					setState(415);
					match(LIKE);
					setState(421);
					switch (_input.LA(1)) {
					case COLON: {
						setState(416);
						match(COLON);
						setState(417);
						_localctx.ID = match(ID);

						if (_localctx.op.getType() == LEFT) {
							builder.pushLeftLikeParam(_localctx.ID.getText());
						} else {
							builder.pushAllLikeParam(_localctx.ID.getText());
						}

					}
						break;
					case QUEMARK: {
						setState(419);
						match(QUEMARK);

						if (_localctx.op.getType() == LEFT) {
							builder.pushLeftLikeParam(nextParamIndex());
						} else {
							builder.pushAllLikeParam(nextParamIndex());
						}

					}
						break;
					default:
						throw new NoViableAltException(this);
					}

					if (isNot) {
						builder.pushNotLike();
					} else {
						builder.pushLike();
					}

				}
					break;
				case 4: {
					setState(425);
					expression(0);

					boolean isNot = false;

					setState(429);
					_la = _input.LA(1);
					if (_la == NOT) {
						{
							setState(427);
							match(NOT);

							isNot = true;

						}
					}

					setState(431);
					match(IN);
					setState(434);
					switch (getInterpreter().adaptivePredict(_input, 51, _ctx)) {
					case 1: {
						setState(432);
						list();
					}
						break;
					case 2: {
						setState(433);
						subquery();
					}
						break;
					}

					if (isNot) {
						builder.pushNotIn();
					} else {
						builder.pushIn();
					}

				}
					break;
				case 5: {

					boolean isNot = false;

					setState(441);
					_la = _input.LA(1);
					if (_la == NOT) {
						{
							setState(439);
							match(NOT);

							isNot = true;

						}
					}

					setState(443);
					match(EXISTS);
					setState(444);
					subquery();

					if (isNot) {
						builder.pushNotExists();
					} else {
						builder.pushExists();
					}

				}
					break;
				case 6: {
					setState(447);
					expression(0);
					setState(448);
					match(IS);

					boolean isNot = false;

					setState(452);
					_la = _input.LA(1);
					if (_la == NOT) {
						{
							setState(450);
							match(NOT);

							isNot = true;

						}
					}

					setState(454);
					match(NULL);

					if (isNot) {
						builder.pushNotNull();
					} else {
						builder.pushNull();
					}

				}
					break;
				case 7: {
					setState(457);
					expression(0);
					setState(458);
					match(BETWEEN);
					setState(459);
					expression(0);
					setState(460);
					match(AND);
					setState(461);
					expression(0);

					builder.pushBetween();

				}
					break;
				case 8: {
					setState(464);
					match(L_BRACKET);
					setState(465);
					condition(0);
					setState(466);
					match(R_BRACKET);

					builder.pushBracket();

				}
					break;
				}
				_ctx.stop = _input.LT(-1);
				setState(483);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input, 56, _ctx);
				while (_alt != 2 && _alt != org.codefinger.dao.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) {
					if (_alt == 1) {
						if (_parseListeners != null)
							triggerExitRuleEvent();
						_prevctx = _localctx;
						{
							setState(481);
							switch (getInterpreter().adaptivePredict(_input, 55, _ctx)) {
							case 1: {
								_localctx = new ConditionContext(_parentctx, _parentState);
								pushNewRecursionContext(_localctx, _startState, RULE_condition);
								setState(471);
								if (!(precpred(_ctx, 3)))
									throw new FailedPredicateException(this, "precpred(_ctx, 3)");
								setState(472);
								match(AND);
								setState(473);
								condition(4);

								builder.pushAnd();

							}
								break;
							case 2: {
								_localctx = new ConditionContext(_parentctx, _parentState);
								pushNewRecursionContext(_localctx, _startState, RULE_condition);
								setState(476);
								if (!(precpred(_ctx, 2)))
									throw new FailedPredicateException(this, "precpred(_ctx, 2)");
								setState(477);
								match(OR);
								setState(478);
								condition(3);

								builder.pushOr();

							}
								break;
							}
						}
					}
					setState(485);
					_errHandler.sync(this);
					_alt = getInterpreter().adaptivePredict(_input, 56, _ctx);
				}
			}
		} catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		} finally {
			unrollRecursionContexts(_parentctx);
		}
		return _localctx;
	}

	public static class ListContext extends ParserRuleContext {
		public TerminalNode L_BRACKET() {
			return getToken(QueryParser.L_BRACKET, 0);
		}

		public TerminalNode R_BRACKET() {
			return getToken(QueryParser.R_BRACKET, 0);
		}

		public List<ListItemContext> listItem() {
			return getRuleContexts(ListItemContext.class);
		}

		public ListItemContext listItem(int i) {
			return getRuleContext(ListItemContext.class, i);
		}

		public List<TerminalNode> COMMA() {
			return getTokens(QueryParser.COMMA);
		}

		public TerminalNode COMMA(int i) {
			return getToken(QueryParser.COMMA, i);
		}

		public ListContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}

		@Override
		public int getRuleIndex() {
			return RULE_list;
		}
	}

	public final ListContext list() throws RecognitionException {
		ListContext _localctx = new ListContext(_ctx, getState());
		enterRule(_localctx, 30, RULE_list);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
				setState(486);
				match(L_BRACKET);
				{
					setState(487);
					listItem();
				}

				int length = 1;

				setState(495);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while (_la == COMMA) {
					{
						{
							setState(489);
							match(COMMA);
							setState(490);
							listItem();

							length++;

						}
					}
					setState(497);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				setState(498);
				match(R_BRACKET);

				builder.pushList(length);

			}
		} catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		} finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ListItemContext extends ParserRuleContext {
		public Token	ID;

		public TerminalNode COLON() {
			return getToken(QueryParser.COLON, 0);
		}

		public TerminalNode ID() {
			return getToken(QueryParser.ID, 0);
		}

		public TerminalNode QUEMARK() {
			return getToken(QueryParser.QUEMARK, 0);
		}

		public ExpressionContext expression() {
			return getRuleContext(ExpressionContext.class, 0);
		}

		public ListItemContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}

		@Override
		public int getRuleIndex() {
			return RULE_listItem;
		}
	}

	public final ListItemContext listItem() throws RecognitionException {
		ListItemContext _localctx = new ListItemContext(_ctx, getState());
		enterRule(_localctx, 32, RULE_listItem);
		try {
			setState(507);
			switch (getInterpreter().adaptivePredict(_input, 58, _ctx)) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
					setState(501);
					match(COLON);
					setState(502);
					_localctx.ID = match(ID);

					builder.pushListParam(_localctx.ID.getText());

				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
					setState(504);
					match(QUEMARK);

					builder.pushListParam(nextParamIndex());

				}
				break;
			case 3:
				enterOuterAlt(_localctx, 3);
				{
					setState(506);
					expression(0);
				}
				break;
			}
		} catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		} finally {
			exitRule();
		}
		return _localctx;
	}

	public static class SetValuesContext extends ParserRuleContext {
		public List<SetValueContext> setValue() {
			return getRuleContexts(SetValueContext.class);
		}

		public SetValueContext setValue(int i) {
			return getRuleContext(SetValueContext.class, i);
		}

		public List<TerminalNode> COMMA() {
			return getTokens(QueryParser.COMMA);
		}

		public TerminalNode COMMA(int i) {
			return getToken(QueryParser.COMMA, i);
		}

		public SetValuesContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}

		@Override
		public int getRuleIndex() {
			return RULE_setValues;
		}
	}

	public final SetValuesContext setValues() throws RecognitionException {
		SetValuesContext _localctx = new SetValuesContext(_ctx, getState());
		enterRule(_localctx, 34, RULE_setValues);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
				setState(509);
				setValue();
				setState(514);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while (_la == COMMA) {
					{
						{
							setState(510);
							match(COMMA);
							setState(511);
							setValue();
						}
					}
					setState(516);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
			}
		} catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		} finally {
			exitRule();
		}
		return _localctx;
	}

	public static class SetValueContext extends ParserRuleContext {
		public Token	ID;

		public TerminalNode ID() {
			return getToken(QueryParser.ID, 0);
		}

		public TerminalNode EQ() {
			return getToken(QueryParser.EQ, 0);
		}

		public ExpressionContext expression() {
			return getRuleContext(ExpressionContext.class, 0);
		}

		public SetValueContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}

		@Override
		public int getRuleIndex() {
			return RULE_setValue;
		}
	}

	public final SetValueContext setValue() throws RecognitionException {
		SetValueContext _localctx = new SetValueContext(_ctx, getState());
		enterRule(_localctx, 36, RULE_setValue);
		try {
			enterOuterAlt(_localctx, 1);
			{
				setState(517);
				_localctx.ID = match(ID);
				setState(518);
				match(EQ);
				setState(519);
				expression(0);

				builder.setValue(_localctx.ID.getText());

			}
		} catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		} finally {
			exitRule();
		}
		return _localctx;
	}

	public static class InsertContext extends ParserRuleContext {
		public List<InsertValueContext> insertValue() {
			return getRuleContexts(InsertValueContext.class);
		}

		public InsertValueContext insertValue(int i) {
			return getRuleContext(InsertValueContext.class, i);
		}

		public List<TerminalNode> COMMA() {
			return getTokens(QueryParser.COMMA);
		}

		public TerminalNode COMMA(int i) {
			return getToken(QueryParser.COMMA, i);
		}

		public InsertContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}

		@Override
		public int getRuleIndex() {
			return RULE_insert;
		}
	}

	public final InsertContext insert() throws RecognitionException {
		InsertContext _localctx = new InsertContext(_ctx, getState());
		enterRule(_localctx, 38, RULE_insert);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
				setState(522);
				insertValue();
				setState(527);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while (_la == COMMA) {
					{
						{
							setState(523);
							match(COMMA);
							setState(524);
							insertValue();
						}
					}
					setState(529);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
			}
		} catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		} finally {
			exitRule();
		}
		return _localctx;
	}

	public static class InsertValueContext extends ParserRuleContext {
		public Token	ID;

		public TerminalNode ID() {
			return getToken(QueryParser.ID, 0);
		}

		public TerminalNode EQ() {
			return getToken(QueryParser.EQ, 0);
		}

		public ExpressionContext expression() {
			return getRuleContext(ExpressionContext.class, 0);
		}

		public InsertValueContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}

		@Override
		public int getRuleIndex() {
			return RULE_insertValue;
		}
	}

	public final InsertValueContext insertValue() throws RecognitionException {
		InsertValueContext _localctx = new InsertValueContext(_ctx, getState());
		enterRule(_localctx, 40, RULE_insertValue);
		try {
			enterOuterAlt(_localctx, 1);
			{
				setState(530);
				_localctx.ID = match(ID);
				setState(531);
				match(EQ);
				setState(532);
				expression(0);

				builder.insertValue(_localctx.ID.getText());

			}
		} catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		} finally {
			exitRule();
		}
		return _localctx;
	}

	@Override
	public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) {
		switch (ruleIndex) {
		case 13:
			return expression_sempred((ExpressionContext) _localctx, predIndex);
		case 14:
			return condition_sempred((ConditionContext) _localctx, predIndex);
		}
		return true;
	}

	private boolean expression_sempred(ExpressionContext _localctx, int predIndex) {
		switch (predIndex) {
		case 0:
			return precpred(_ctx, 4);
		case 1:
			return precpred(_ctx, 3);
		}
		return true;
	}

	private boolean condition_sempred(ConditionContext _localctx, int predIndex) {
		switch (predIndex) {
		case 2:
			return precpred(_ctx, 3);
		case 3:
			return precpred(_ctx, 2);
		}
		return true;
	}

	public static final String	_serializedATN	= "\3\u0430\ud6d1\u8206\uad2d\u4417\uaef1\u8d80\uaadd\3<\u021a\4\2\t\2\4" + "\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t" + "\13\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22" + "\4\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26\3\2\3\2\3\2\5\2\60\n\2\3\2\3" + "\2\3\2\3\2\7\2\66\n\2\f\2\16\29\13\2\3\2\3\2\5\2=\n\2\3\2\3\2\3\2\5\2" + "B\n\2\3\2\5\2E\n\2\3\2\7\2H\n\2\f\2\16\2K\13\2\3\2\3\2\3\2\5\2P\n\2\3" + "\3\3\3\3\3\3\3\3\3\7\3W\n\3\f\3\16\3Z\13\3\5\3\\\n\3\3\4\3\4\3\4\3\4\3" + "\4\3\4\3\4\3\4\3\4\3\4\3\4\5\4i\n\4\3\4\5\4l\n\4\3\4\3\4\5\4p\n\4\3\4" + "\3\4\3\4\3\4\5\4v\n\4\3\4\3\4\5\4z\n\4\3\4\3\4\5\4~\n\4\3\5\3\5\3\5\5" + "\5\u0083\n\5\3\5\3\5\5\5\u0087\n\5\3\5\3\5\3\5\3\5\3\5\3\5\5\5\u008f\n" + "\5\3\5\3\5\5\5\u0093\n\5\3\5\3\5\5\5\u0097\n\5\3\6\3\6\3\6\3\6\3\6\5\6" + "\u009e\n\6\3\6\3\6\5\6\u00a2\n\6\3\6\3\6\3\6\3\6\3\7\3\7\3\7\3\7\3\b\3" + "\b\3\b\7\b\u00af\n\b\f\b\16\b\u00b2\13\b\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3" + "\t\3\t\3\t\5\t\u00be\n\t\3\n\3\n\3\n\3\n\3\13\3\13\3\13\3\13\5\13\u00c8" + "\n\13\3\13\3\13\3\13\3\13\5\13\u00ce\n\13\3\13\3\13\3\13\3\13\7\13\u00d4" + "\n\13\f\13\16\13\u00d7\13\13\3\13\3\13\5\13\u00db\n\13\3\13\3\13\3\13" + "\5\13\u00e0\n\13\3\13\5\13\u00e3\n\13\3\13\3\13\3\f\3\f\3\f\7\f\u00ea" + "\n\f\f\f\16\f\u00ed\13\f\3\r\3\r\5\r\u00f1\n\r\3\r\3\r\3\16\3\16\3\16" + "\3\16\3\16\5\16\u00fa\n\16\3\16\3\16\3\16\3\16\7\16\u0100\n\16\f\16\16" + "\16\u0103\13\16\3\16\3\16\5\16\u0107\n\16\3\16\3\16\3\16\5\16\u010c\n" + "\16\3\16\5\16\u010f\n\16\3\16\7\16\u0112\n\16\f\16\16\16\u0115\13\16\3" + "\16\3\16\3\16\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3" + "\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\5" + "\17\u0133\n\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17" + "\3\17\3\17\7\17\u0142\n\17\f\17\16\17\u0145\13\17\5\17\u0147\n\17\3\17" + "\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17" + "\3\17\6\17\u0159\n\17\r\17\16\17\u015a\3\17\3\17\3\17\3\17\3\17\3\17\3" + "\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\6\17\u016b\n\17\r\17\16\17\u016c" + "\3\17\3\17\3\17\3\17\3\17\5\17\u0174\n\17\3\17\3\17\3\17\3\17\3\17\3\17" + "\3\17\3\17\3\17\3\17\7\17\u0180\n\17\f\17\16\17\u0183\13\17\3\20\3\20" + "\3\20\3\20\3\20\3\20\3\20\3\20\5\20\u018d\n\20\3\20\3\20\3\20\3\20\3\20" + "\3\20\5\20\u0195\n\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\5\20\u019f" + "\n\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\5\20\u01a8\n\20\3\20\3\20\3\20" + "\3\20\3\20\3\20\5\20\u01b0\n\20\3\20\3\20\3\20\5\20\u01b5\n\20\3\20\3" + "\20\3\20\3\20\3\20\5\20\u01bc\n\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20" + "\3\20\3\20\5\20\u01c7\n\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20" + "\3\20\3\20\3\20\3\20\3\20\3\20\5\20\u01d8\n\20\3\20\3\20\3\20\3\20\3\20" + "\3\20\3\20\3\20\3\20\3\20\7\20\u01e4\n\20\f\20\16\20\u01e7\13\20\3\21" + "\3\21\3\21\3\21\3\21\3\21\3\21\7\21\u01f0\n\21\f\21\16\21\u01f3\13\21" + "\3\21\3\21\3\21\3\22\3\22\3\22\3\22\3\22\3\22\5\22\u01fe\n\22\3\23\3\23" + "\3\23\7\23\u0203\n\23\f\23\16\23\u0206\13\23\3\24\3\24\3\24\3\24\3\24" + "\3\25\3\25\3\25\7\25\u0210\n\25\f\25\16\25\u0213\13\25\3\26\3\26\3\26" + "\3\26\3\26\3\26\2\4\34\36\27\2\4\6\b\n\f\16\20\22\24\26\30\32\34\36 \"" + "$&(*\2\n\3\2\r\16\3\2\30\31\3\2\6\n\4\2))\60\60\4\2//\61\61\3\2\62\67" + "\4\2\26\26\32\32\4\2\16\16\26\26\u0255\2,\3\2\2\2\4[\3\2\2\2\6}\3\2\2" + "\2\b\u0096\3\2\2\2\n\u0098\3\2\2\2\f\u00a7\3\2\2\2\16\u00ab\3\2\2\2\20" + "\u00bd\3\2\2\2\22\u00bf\3\2\2\2\24\u00c3\3\2\2\2\26\u00e6\3\2\2\2\30\u00ee" + "\3\2\2\2\32\u00f4\3\2\2\2\34\u0173\3\2\2\2\36\u01d7\3\2\2\2 \u01e8\3\2" + "\2\2\"\u01fd\3\2\2\2$\u01ff\3\2\2\2&\u0207\3\2\2\2(\u020c\3\2\2\2*\u0214" + "\3\2\2\2,/\7\3\2\2-.\7\4\2\2.\60\b\2\1\2/-\3\2\2\2/\60\3\2\2\2\60\61\3" + "\2\2\2\61\62\5\4\3\2\62\63\7\13\2\2\63\67\5\b\5\2\64\66\5\n\6\2\65\64" + "\3\2\2\2\669\3\2\2\2\67\65\3\2\2\2\678\3\2\2\28:\3\2\2\29\67\3\2\2\2:" + "<\b\2\1\2;=\5\f\7\2<;\3\2\2\2<=\3\2\2\2=A\3\2\2\2>?\7\22\2\2?@\7\23\2" + "\2@B\5\16\b\2A>\3\2\2\2AB\3\2\2\2BD\3\2\2\2CE\5\22\n\2DC\3\2\2\2DE\3\2" + "\2\2EI\3\2\2\2FH\5\24\13\2GF\3\2\2\2HK\3\2\2\2IG\3\2\2\2IJ\3\2\2\2JO\3" + "\2\2\2KI\3\2\2\2LM\7\27\2\2MN\7\23\2\2NP\5\26\f\2OL\3\2\2\2OP\3\2\2\2" + "P\3\3\2\2\2QR\7)\2\2R\\\b\3\1\2SX\5\6\4\2TU\7*\2\2UW\5\6\4\2VT\3\2\2\2" + "WZ\3\2\2\2XV\3\2\2\2XY\3\2\2\2Y\\\3\2\2\2ZX\3\2\2\2[Q\3\2\2\2[S\3\2\2" + "\2\\\5\3\2\2\2]^\79\2\2^_\7+\2\2_`\7)\2\2`~\b\4\1\2ah\b\4\1\2bc\79\2\2" + "ci\b\4\1\2de\79\2\2ef\7+\2\2fg\79\2\2gi\b\4\1\2hb\3\2\2\2hd\3\2\2\2io" + "\3\2\2\2jl\7\5\2\2kj\3\2\2\2kl\3\2\2\2lm\3\2\2\2mn\79\2\2np\b\4\1\2ok" + "\3\2\2\2op\3\2\2\2pq\3\2\2\2q~\b\4\1\2rs\b\4\1\2sy\5\34\17\2tv\7\5\2\2" + "ut\3\2\2\2uv\3\2\2\2vw\3\2\2\2wx\79\2\2xz\b\4\1\2yu\3\2\2\2yz\3\2\2\2" + "z{\3\2\2\2{|\b\4\1\2|~\3\2\2\2}]\3\2\2\2}a\3\2\2\2}r\3\2\2\2~\7\3\2\2" + "\2\177\u0080\b\5\1\2\u0080\u0086\79\2\2\u0081\u0083\7\5\2\2\u0082\u0081" + "\3\2\2\2\u0082\u0083\3\2\2\2\u0083\u0084\3\2\2\2\u0084\u0085\79\2\2\u0085" + "\u0087\b\5\1\2\u0086\u0082\3\2\2\2\u0086\u0087\3\2\2\2\u0087\u0088\3\2" + "\2\2\u0088\u0097\b\5\1\2\u0089\u008a\7-\2\2\u008a\u008b\b\5\1\2\u008b" + "\u008c\5\2\2\2\u008c\u0092\7.\2\2\u008d\u008f\7\5\2\2\u008e\u008d\3\2" + "\2\2\u008e\u008f\3\2\2\2\u008f\u0090\3\2\2\2\u0090\u0091\79\2\2\u0091" + "\u0093\b\5\1\2\u0092\u008e\3\2\2\2\u0092\u0093\3\2\2\2\u0093\u0094\3\2" + "\2\2\u0094\u0095\b\5\1\2\u0095\u0097\3\2\2\2\u0096\177\3\2\2\2\u0096\u0089" + "\3\2\2\2\u0097\t\3\2\2\2\u0098\u0099\t\2\2\2\u0099\u009a\b\6\1\2\u009a" + "\u009b\7\17\2\2\u009b\u00a1\79\2\2\u009c\u009e\7\5\2\2\u009d\u009c\3\2" + "\2\2\u009d\u009e\3\2\2\2\u009e\u009f\3\2\2\2\u009f\u00a0\79\2\2\u00a0" + "\u00a2\b\6\1\2\u00a1\u009d\3\2\2\2\u00a1\u00a2\3\2\2\2\u00a2\u00a3\3\2" + "\2\2\u00a3\u00a4\7\20\2\2\u00a4\u00a5\5\36\20\2\u00a5\u00a6\b\6\1\2\u00a6" + "\13\3\2\2\2\u00a7\u00a8\7\21\2\2\u00a8\u00a9\5\36\20\2\u00a9\u00aa\b\7" + "\1\2\u00aa\r\3\2\2\2\u00ab\u00b0\5\20\t\2\u00ac\u00ad\7*\2\2\u00ad\u00af" + "\5\20\t\2\u00ae\u00ac\3\2\2\2\u00af\u00b2\3\2\2\2\u00b0\u00ae\3\2\2\2" + "\u00b0\u00b1\3\2\2\2\u00b1\17\3\2\2\2\u00b2\u00b0\3\2\2\2\u00b3\u00b4" + "\79\2\2\u00b4\u00be\b\t\1\2\u00b5\u00b6\79\2\2\u00b6\u00b7\7+\2\2\u00b7" + "\u00b8\79\2\2\u00b8\u00be\b\t\1\2\u00b9\u00ba\79\2\2\u00ba\u00bb\7+\2" + "\2\u00bb\u00bc\7)\2\2\u00bc\u00be\b\t\1\2\u00bd\u00b3\3\2\2\2\u00bd\u00b5" + "\3\2\2\2\u00bd\u00b9\3\2\2\2\u00be\21\3\2\2\2\u00bf\u00c0\7\24\2\2\u00c0" + "\u00c1\5\36\20\2\u00c1\u00c2\b\n\1\2\u00c2\23\3\2\2\2\u00c3\u00c4\7\25" + "\2\2\u00c4\u00c7\b\13\1\2\u00c5\u00c6\7\26\2\2\u00c6\u00c8\b\13\1\2\u00c7" + "\u00c5\3\2\2\2\u00c7\u00c8\3\2\2\2\u00c8\u00c9\3\2\2\2\u00c9\u00ca\b\13" + "\1\2\u00ca\u00cd\7\3\2\2\u00cb\u00cc\7\4\2\2\u00cc\u00ce\b\13\1\2\u00cd" + "\u00cb\3\2\2\2\u00cd\u00ce\3\2\2\2\u00ce\u00cf\3\2\2\2\u00cf\u00d0\5\4" + "\3\2\u00d0\u00d1\7\13\2\2\u00d1\u00d5\5\b\5\2\u00d2\u00d4\5\n\6\2\u00d3" + "\u00d2\3\2\2\2\u00d4\u00d7\3\2\2\2\u00d5\u00d3\3\2\2\2\u00d5\u00d6\3\2" + "\2\2\u00d6\u00d8\3\2\2\2\u00d7\u00d5\3\2\2\2\u00d8\u00da\b\13\1\2\u00d9" + "\u00db\5\f\7\2\u00da\u00d9\3\2\2\2\u00da\u00db\3\2\2\2\u00db\u00df\3\2" + "\2\2\u00dc\u00dd\7\22\2\2\u00dd\u00de\7\23\2\2\u00de\u00e0\5\16\b\2\u00df" + "\u00dc\3\2\2\2\u00df\u00e0\3\2\2\2\u00e0\u00e2\3\2\2\2\u00e1\u00e3\5\22" + "\n\2\u00e2\u00e1\3\2\2\2\u00e2\u00e3\3\2\2\2\u00e3\u00e4\3\2\2\2\u00e4" + "\u00e5\b\13\1\2\u00e5\25\3\2\2\2\u00e6\u00eb\5\30\r\2\u00e7\u00e8\7*\2" + "\2\u00e8\u00ea\5\30\r\2\u00e9\u00e7\3\2\2\2\u00ea\u00ed\3\2\2\2\u00eb" + "\u00e9\3\2\2\2\u00eb\u00ec\3\2\2\2\u00ec\27\3\2\2\2\u00ed\u00eb\3\2\2" + "\2\u00ee\u00f0\5\34\17\2\u00ef\u00f1\t\3\2\2\u00f0\u00ef\3\2\2\2\u00f0" + "\u00f1\3\2\2\2\u00f1\u00f2\3\2\2\2\u00f2\u00f3\b\r\1\2\u00f3\31\3\2\2" + "\2\u00f4\u00f5\7-\2\2\u00f5\u00f6\b\16\1\2\u00f6\u00f9\7\3\2\2\u00f7\u00f8" + "\7\4\2\2\u00f8\u00fa\b\16\1\2\u00f9\u00f7\3\2\2\2\u00f9\u00fa\3\2\2\2" + "\u00fa\u00fb\3\2\2\2\u00fb\u00fc\5\4\3\2\u00fc\u00fd\7\13\2\2\u00fd\u0101" + "\5\b\5\2\u00fe\u0100\5\n\6\2\u00ff\u00fe\3\2\2\2\u0100\u0103\3\2\2\2\u0101" + "\u00ff\3\2\2\2\u0101\u0102\3\2\2\2\u0102\u0104\3\2\2\2\u0103\u0101\3\2" + "\2\2\u0104\u0106\b\16\1\2\u0105\u0107\5\f\7\2\u0106\u0105\3\2\2\2\u0106" + "\u0107\3\2\2\2\u0107\u010b\3\2\2\2\u0108\u0109\7\22\2\2\u0109\u010a\7" + "\23\2\2\u010a\u010c\5\16\b\2\u010b\u0108\3\2\2\2\u010b\u010c\3\2\2\2\u010c" + "\u010e\3\2\2\2\u010d\u010f\5\22\n\2\u010e\u010d\3\2\2\2\u010e\u010f\3" + "\2\2\2\u010f\u0113\3\2\2\2\u0110\u0112\5\24\13\2\u0111\u0110\3\2\2\2\u0112" + "\u0115\3\2\2\2\u0113\u0111\3\2\2\2\u0113\u0114\3\2\2\2\u0114\u0116\3\2" + "\2\2\u0115\u0113\3\2\2\2\u0116\u0117\7.\2\2\u0117\u0118\b\16\1\2\u0118" + "\33\3\2\2\2\u0119\u011a\b\17\1\2\u011a\u011b\7/\2\2\u011b\u011c\5\34\17" + "\b\u011c\u011d\b\17\1\2\u011d\u0174\3\2\2\2\u011e\u011f\79\2\2\u011f\u0174" + "\b\17\1\2\u0120\u0121\79\2\2\u0121\u0122\7+\2\2\u0122\u0123\79\2\2\u0123" + "\u0174\b\17\1\2\u0124\u0125\7:\2\2\u0125\u0174\b\17\1\2\u0126\u0127\7" + ";\2\2\u0127\u0174\b\17\1\2\u0128\u0129\7,\2\2\u0129\u012a\79\2\2\u012a" + "\u0174\b\17\1\2\u012b\u012c\78\2\2\u012c\u0174\b\17\1\2\u012d\u012e\t" + "\4\2\2\u012e\u012f\7-\2\2\u012f\u0132\b\17\1\2\u0130\u0131\7\4\2\2\u0131" + "\u0133\b\17\1\2\u0132\u0130\3\2\2\2\u0132\u0133\3\2\2\2\u0133\u0134\3" + "\2\2\2\u0134\u0135\5\34\17\2\u0135\u0136\7.\2\2\u0136\u0137\b\17\1\2\u0137" + "\u0174\3\2\2\2\u0138\u0139\79\2\2\u0139\u013a\7-\2\2\u013a\u0146\b\17" + "\1\2\u013b\u013c\5\34\17\2\u013c\u0143\b\17\1\2\u013d\u013e\7*\2\2\u013e" + "\u013f\5\34\17\2\u013f\u0140\b\17\1\2\u0140\u0142\3\2\2\2\u0141\u013d" + "\3\2\2\2\u0142\u0145\3\2\2\2\u0143\u0141\3\2\2\2\u0143\u0144\3\2\2\2\u0144" + "\u0147\3\2\2\2\u0145\u0143\3\2\2\2\u0146\u013b\3\2\2\2\u0146\u0147\3\2" + "\2\2\u0147\u0148\3\2\2\2\u0148\u0149\7.\2\2\u0149\u0174\b\17\1\2\u014a" + "\u0174\5\32\16\2\u014b\u014c\7-\2\2\u014c\u014d\5\34\17\2\u014d\u014e" + "\7.\2\2\u014e\u014f\b\17\1\2\u014f\u0174\3\2\2\2\u0150\u0151\7!\2\2\u0151" + "\u0158\b\17\1\2\u0152\u0153\7\"\2\2\u0153\u0154\5\36\20\2\u0154\u0155"
														+ "\7#\2\2\u0155\u0156\5\34\17\2\u0156\u0157\b\17\1\2\u0157\u0159\3\2\2\2" + "\u0158\u0152\3\2\2\2\u0159\u015a\3\2\2\2\u015a\u0158\3\2\2\2\u015a\u015b" + "\3\2\2\2\u015b\u015c\3\2\2\2\u015c\u015d\7$\2\2\u015d\u015e\5\34\17\2" + "\u015e\u015f\7%\2\2\u015f\u0160\b\17\1\2\u0160\u0174\3\2\2\2\u0161\u0162" + "\7!\2\2\u0162\u0163\5\34\17\2\u0163\u016a\b\17\1\2\u0164\u0165\7\"\2\2" + "\u0165\u0166\5\34\17\2\u0166\u0167\7#\2\2\u0167\u0168\5\34\17\2\u0168" + "\u0169\b\17\1\2\u0169\u016b\3\2\2\2\u016a\u0164\3\2\2\2\u016b\u016c\3" + "\2\2\2\u016c\u016a\3\2\2\2\u016c\u016d\3\2\2\2\u016d\u016e\3\2\2\2\u016e" + "\u016f\7$\2\2\u016f\u0170\5\34\17\2\u0170\u0171\7%\2\2\u0171\u0172\b\17" + "\1\2\u0172\u0174\3\2\2\2\u0173\u0119\3\2\2\2\u0173\u011e\3\2\2\2\u0173" + "\u0120\3\2\2\2\u0173\u0124\3\2\2\2\u0173\u0126\3\2\2\2\u0173\u0128\3\2" + "\2\2\u0173\u012b\3\2\2\2\u0173\u012d\3\2\2\2\u0173\u0138\3\2\2\2\u0173" + "\u014a\3\2\2\2\u0173\u014b\3\2\2\2\u0173\u0150\3\2\2\2\u0173\u0161\3\2" + "\2\2\u0174\u0181\3\2\2\2\u0175\u0176\f\6\2\2\u0176\u0177\t\5\2\2\u0177" + "\u0178\5\34\17\7\u0178\u0179\b\17\1\2\u0179\u0180\3\2\2\2\u017a\u017b" + "\f\5\2\2\u017b\u017c\t\6\2\2\u017c\u017d\5\34\17\6\u017d\u017e\b\17\1" + "\2\u017e\u0180\3\2\2\2\u017f\u0175\3\2\2\2\u017f\u017a\3\2\2\2\u0180\u0183" + "\3\2\2\2\u0181\u017f\3\2\2\2\u0181\u0182\3\2\2\2\u0182\35\3\2\2\2\u0183" + "\u0181\3\2\2\2\u0184\u0185\b\20\1\2\u0185\u0186\5\34\17\2\u0186\u018c" + "\t\7\2\2\u0187\u018d\5\34\17\2\u0188\u0189\t\b\2\2\u0189\u018a\5\32\16" + "\2\u018a\u018b\b\20\1\2\u018b\u018d\3\2\2\2\u018c\u0187\3\2\2\2\u018c" + "\u0188\3\2\2\2\u018d\u018e\3\2\2\2\u018e\u018f\b\20\1\2\u018f\u01d8\3" + "\2\2\2\u0190\u0191\5\34\17\2\u0191\u0194\b\20\1\2\u0192\u0193\7\36\2\2" + "\u0193\u0195\b\20\1\2\u0194\u0192\3\2\2\2\u0194\u0195\3\2\2\2\u0195\u0196" + "\3\2\2\2\u0196\u0197\7\34\2\2\u0197\u0198\5\34\17\2\u0198\u0199\b\20\1" + "\2\u0199\u01d8\3\2\2\2\u019a\u019b\5\34\17\2\u019b\u019e\b\20\1\2\u019c" + "\u019d\7\36\2\2\u019d\u019f\b\20\1\2\u019e\u019c\3\2\2\2\u019e\u019f\3" + "\2\2\2\u019f\u01a0\3\2\2\2\u01a0\u01a1\t\t\2\2\u01a1\u01a7\7\34\2\2\u01a2" + "\u01a3\7,\2\2\u01a3\u01a4\79\2\2\u01a4\u01a8\b\20\1\2\u01a5\u01a6\78\2" + "\2\u01a6\u01a8\b\20\1\2\u01a7\u01a2\3\2\2\2\u01a7\u01a5\3\2\2\2\u01a8" + "\u01a9\3\2\2\2\u01a9\u01aa\b\20\1\2\u01aa\u01d8\3\2\2\2\u01ab\u01ac\5" + "\34\17\2\u01ac\u01af\b\20\1\2\u01ad\u01ae\7\36\2\2\u01ae\u01b0\b\20\1" + "\2\u01af\u01ad\3\2\2\2\u01af\u01b0\3\2\2\2\u01b0\u01b1\3\2\2\2\u01b1\u01b4" + "\7\35\2\2\u01b2\u01b5\5 \21\2\u01b3\u01b5\5\32\16\2\u01b4\u01b2\3\2\2" + "\2\u01b4\u01b3\3\2\2\2\u01b5\u01b6\3\2\2\2\u01b6\u01b7\b\20\1\2\u01b7" + "\u01d8\3\2\2\2\u01b8\u01bb\b\20\1\2\u01b9\u01ba\7\36\2\2\u01ba\u01bc\b" + "\20\1\2\u01bb\u01b9\3\2\2\2\u01bb\u01bc\3\2\2\2\u01bc\u01bd\3\2\2\2\u01bd" + "\u01be\7\33\2\2\u01be\u01bf\5\32\16\2\u01bf\u01c0\b\20\1\2\u01c0\u01d8" + "\3\2\2\2\u01c1\u01c2\5\34\17\2\u01c2\u01c3\7\37\2\2\u01c3\u01c6\b\20\1" + "\2\u01c4\u01c5\7\36\2\2\u01c5\u01c7\b\20\1\2\u01c6\u01c4\3\2\2\2\u01c6" + "\u01c7\3\2\2\2\u01c7\u01c8\3\2\2\2\u01c8\u01c9\7 \2\2\u01c9\u01ca\b\20" + "\1\2\u01ca\u01d8\3\2\2\2\u01cb\u01cc\5\34\17\2\u01cc\u01cd\7&\2\2\u01cd" + "\u01ce\5\34\17\2\u01ce\u01cf\7\'\2\2\u01cf\u01d0\5\34\17\2\u01d0\u01d1" + "\b\20\1\2\u01d1\u01d8\3\2\2\2\u01d2\u01d3\7-\2\2\u01d3\u01d4\5\36\20\2" + "\u01d4\u01d5\7.\2\2\u01d5\u01d6\b\20\1\2\u01d6\u01d8\3\2\2\2\u01d7\u0184" + "\3\2\2\2\u01d7\u0190\3\2\2\2\u01d7\u019a\3\2\2\2\u01d7\u01ab\3\2\2\2\u01d7" + "\u01b8\3\2\2\2\u01d7\u01c1\3\2\2\2\u01d7\u01cb\3\2\2\2\u01d7\u01d2\3\2" + "\2\2\u01d8\u01e5\3\2\2\2\u01d9\u01da\f\5\2\2\u01da\u01db\7\'\2\2\u01db" + "\u01dc\5\36\20\6\u01dc\u01dd\b\20\1\2\u01dd\u01e4\3\2\2\2\u01de\u01df" + "\f\4\2\2\u01df\u01e0\7(\2\2\u01e0\u01e1\5\36\20\5\u01e1\u01e2\b\20\1\2" + "\u01e2\u01e4\3\2\2\2\u01e3\u01d9\3\2\2\2\u01e3\u01de\3\2\2\2\u01e4\u01e7" + "\3\2\2\2\u01e5\u01e3\3\2\2\2\u01e5\u01e6\3\2\2\2\u01e6\37\3\2\2\2\u01e7" + "\u01e5\3\2\2\2\u01e8\u01e9\7-\2\2\u01e9\u01ea\5\"\22\2\u01ea\u01f1\b\21" + "\1\2\u01eb\u01ec\7*\2\2\u01ec\u01ed\5\"\22\2\u01ed\u01ee\b\21\1\2\u01ee" + "\u01f0\3\2\2\2\u01ef\u01eb\3\2\2\2\u01f0\u01f3\3\2\2\2\u01f1\u01ef\3\2" + "\2\2\u01f1\u01f2\3\2\2\2\u01f2\u01f4\3\2\2\2\u01f3\u01f1\3\2\2\2\u01f4" + "\u01f5\7.\2\2\u01f5\u01f6\b\21\1\2\u01f6!\3\2\2\2\u01f7\u01f8\7,\2\2\u01f8" + "\u01f9\79\2\2\u01f9\u01fe\b\22\1\2\u01fa\u01fb\78\2\2\u01fb\u01fe\b\22" + "\1\2\u01fc\u01fe\5\34\17\2\u01fd\u01f7\3\2\2\2\u01fd\u01fa\3\2\2\2\u01fd" + "\u01fc\3\2\2\2\u01fe#\3\2\2\2\u01ff\u0204\5&\24\2\u0200\u0201\7*\2\2\u0201" + "\u0203\5&\24\2\u0202\u0200\3\2\2\2\u0203\u0206\3\2\2\2\u0204\u0202\3\2" + "\2\2\u0204\u0205\3\2\2\2\u0205%\3\2\2\2\u0206\u0204\3\2\2\2\u0207\u0208" + "\79\2\2\u0208\u0209\7\62\2\2\u0209\u020a\5\34\17\2\u020a\u020b\b\24\1" + "\2\u020b\'\3\2\2\2\u020c\u0211\5*\26\2\u020d\u020e\7*\2\2\u020e\u0210" + "\5*\26\2\u020f\u020d\3\2\2\2\u0210\u0213\3\2\2\2\u0211\u020f\3\2\2\2\u0211" + "\u0212\3\2\2\2\u0212)\3\2\2\2\u0213\u0211\3\2\2\2\u0214\u0215\79\2\2\u0215" + "\u0216\7\62\2\2\u0216\u0217\5\34\17\2\u0217\u0218\b\26\1\2\u0218+\3\2" + "\2\2?/\67<ADIOX[hkouy}\u0082\u0086\u008e\u0092\u0096\u009d\u00a1\u00b0" + "\u00bd\u00c7\u00cd\u00d5\u00da\u00df\u00e2\u00eb\u00f0\u00f9\u0101\u0106" + "\u010b\u010e\u0113\u0132\u0143\u0146\u015a\u016c\u0173\u017f\u0181\u018c" + "\u0194\u019e\u01a7\u01af\u01b4\u01bb\u01c6\u01d7\u01e3\u01e5\u01f1\u01fd" + "\u0204\u0211";
	public static final ATN		_ATN			= new ATNDeserializer().deserialize(_serializedATN.toCharArray());
	static {
		_decisionToDFA = new DFA[_ATN.getNumberOfDecisions()];
		for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) {
			_decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i);
		}
	}
}